1. Field of the Invention
In general, the present invention relates to transformation of JSP containers that are self-contained widgets or components. Specifically, the present invention relates to a method, system and program product for implementing JSP containers as JSF components.
2. Related Art
As the new Java Server Faces (JSF) standard rapidly gains popularity in the industry as an application framework, its function of server-side componentization creates a need to convert existing Java Server Page (JSP) containers into JSF components. Specifically, with the acceptance of JSF as a new standard, and its use of server-side componentization techniques, there is a need to implement containers such as JSP custom tag library containers as JSF components.
Prior to JSF, many Web applications were developed using JSP custom tag libraries. One such example is the International Business Machines (IBM) Rich Text Editor. One possible solution for converting JSP containers such as this into JSF component is to “break up” the containers and re-implement them in a JSF-compliant manner. However, to re-implement a JSP container as a JSF component in this manner is often impossible cost-wise or because there is no access to the original container's source code. Moreover, it is often not possible to run the JSP container directly from a JSF runtime because the JSP container runs in a user-application context, while the JSF runtime has its own context.
One approach, which is referred to herein as a container-based approach, could be to componentize the JSP library as a whole, without modifying the JSP container itself. This method would have the advantage of preserving the original JSP container, thereby reducing cost. Furthermore, as indicated above, it is usually the case that developers do not have access to the JSP containers themselves. As such, there is little chance of re-implementing the JSP containers as JSF components. To this extent, a container-based method would be the only viable mechanism to transform a JSP container to a JSF component. Unfortunately, no existing approach provides a container-based approach. Rather, all existing solutions rely on access to and manipulation of the source code for the JSP container.
In view of the foregoing, there exists a need for a method, system and program product for implementing JSP containers as JSF components. Specifically, a need exists for a container-based approach for this re-implementation that does not require access to or manipulation of the underlying source code of the JSP container.